# Required packages
import pandas as pd
import numpy as np

import catboost

# Sklearn
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, cross_val_score, KFold, StratifiedShuffleSplit
from sklearn import metrics

# Visualisation libraries

## progressbar
import progressbar

## Text
from colorama import Fore, Back, Style
from IPython.display import Image, display, Markdown, Latex, clear_output

## plotly
from plotly.offline import init_notebook_mode, iplot 
import plotly.graph_objs as go
import plotly.offline as py
from plotly.subplots import make_subplots
import plotly.express as px

## seaborn
import seaborn as sns
sns.set_style("whitegrid")
sns.set_context("paper", rc={"font.size":12,"axes.titlesize":14,"axes.labelsize":12})

## matplotlib
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse, Polygon
from matplotlib.font_manager import FontProperties
import matplotlib.colors as mcolors
from matplotlib import cm
plt.style.use('seaborn-whitegrid')
plt.rcParams['axes.labelsize'] = 14
plt.rcParams['xtick.labelsize'] = 12
plt.rcParams['ytick.labelsize'] = 12
plt.rcParams['text.color'] = 'k'
%matplotlib inline

import warnings
warnings.filterwarnings("ignore")

Home / Healthcare Analytics and Modeling

Pima Indians Diabetes

• Preprocessing
• Modeling: scikit-learn Gradient Boosting Classifier
• Modeling: Tensorflow Boosted Trees Classifier
• Modeling: CatBoost Classifier

Pima Indians Diabetes

In this article, we use Kaggle'sPima Indians Diabetes. The Pima Indians are a group of Native Americans living in an area consisting of what is now central and southern Arizona. A variety of statistical methods are used here for predictions.

Context

This dataset is originally from the National Institute of Diabetes and Digestive and Kidney Diseases. The objective of the dataset is to diagnostically predict whether or not a patient has diabetes, based on certain diagnostic measurements included in the dataset. Several constraints were placed on the selection of these instances from a larger database. In particular, all patients here are females at least 21 years old of Pima Indian heritage.

Content

The datasets consist of several medical predictor variables and one target variable, Outcome. Predictor variables include the number of pregnancies the patient has had, their BMI, insulin level, age, and so on.

Feature	Explanations
Pregnancies	Number of times pregnant
Glucose	Plasma glucose concentration a 2 hours in an oral glucose tolerance test
Blood Pressure	Diastolic blood pressure (mm Hg)
Skin Thickness	Triceps skinfold thickness (mm)
Insulin	2-Hour serum insulin (mu U/ml)
BMI	Body mass index (weight in kg/(height in m)^2)
Diabetes Pedigree Function	Diabetes pedigree function
Age	Age (years)
Outcome	Whether or not a patient has diabetes

def Header(Text, L = 100, C = 'Blue', T = 'White'):
    BACK = {'Black': Back.BLACK, 'Red':Back.RED, 'Green':Back.GREEN, 'Yellow': Back.YELLOW, 'Blue': Back.BLUE,
         'Magenta':Back.MAGENTA, 'Cyan': Back.CYAN}
    FORE = {'Black': Fore.BLACK, 'Red':Fore.RED, 'Green':Fore.GREEN, 'Yellow':Fore.YELLOW, 'Blue':Fore.BLUE,
         'Magenta':Fore.MAGENTA, 'Cyan':Fore.CYAN, 'White': Fore.WHITE}
    print(BACK[C] + FORE[T] + Style.NORMAL + Text + Style.RESET_ALL + ' ' + FORE[C] +
          Style.NORMAL +  (L- len(Text) - 1)*'=' + Style.RESET_ALL)
    
def Line(L=100, C = 'Blue'):
    FORE = {'Black': Fore.BLACK, 'Red':Fore.RED, 'Green':Fore.GREEN, 'Yellow':Fore.YELLOW, 'Blue':Fore.BLUE,
         'Magenta':Fore.MAGENTA, 'Cyan':Fore.CYAN, 'White': Fore.WHITE}
    print(FORE[C] + Style.NORMAL + L*'=' + Style.RESET_ALL)

def Search_List(Key, List): return [s for s in List if Key in s]

Data = pd.read_csv('pima-indians-diabetes-database/diabetes_STD.csv')
Header('Standardized Dataset:')
display(Data.head())
display(pd.DataFrame({'Number of Instances': [Data.shape[0]], 'Number of Attributes': [Data.shape[1]]}).style.hide_index())

Standardized Dataset: ==============================================================================

	Pregnancies	Glucose	Blood Pressure	Skin Thickness	Insulin	BMI	Diabetes Pedigree Function	Age	Outcome
0	0.639947	0.848324	0.149641	0.907270	-0.692891	0.204013	0.468492	1.425995	1
1	-0.844885	-1.123396	-0.160546	0.530902	-0.692891	-0.684422	-0.365061	-0.190672	0
2	1.233880	1.943724	-0.263941	-1.288212	-0.692891	-1.103255	0.604397	-0.105584	1
3	-0.844885	-0.998208	-0.160546	0.154533	0.123302	-0.494043	-0.920763	-1.041549	0
4	-1.141852	0.504055	-1.504687	0.907270	0.765836	1.409746	5.484909	-0.020496	1

Number of Instances	Number of Attributes
768	9

Train and Test sets

Target = 'Outcome'
X = Data.drop(columns = [Target])
y = Data[Target]
Labels_dict = dict(zip([0, 1],  ['Non-Diabetic', 'Diabetic']))

def DatasetTargetDist(Inp, Target, Labels_dict, PD):
    # Table
    Table = Inp[Target].value_counts().to_frame('Count').reset_index(drop = False).rename(columns = {'index':Target})
    Table[Target] = Table[Target].replace(Labels_dict)
    Table['Percentage'] = np.round(100*(Table['Count']/Table['Count'].sum()),2)
    fig = make_subplots(rows=1, cols=2, horizontal_spacing = 0.02, column_widths=PD['column_widths'],
                        specs=[[{"type": "table"},{"type": "pie"}]])

    # Right
    fig.add_trace(go.Pie(labels=Table[Target].values, values=Table['Count'].values,
                         pull=PD['pull'], textfont=dict(size= PD['textfont']),
                         marker=dict(colors = PD['PieColors'], line=dict(color='black', width=1))), row=1, col=2)
    fig.update_traces(hole=PD['hole'])
    fig.update_layout(height = PD['height'], legend=dict(orientation="v"), legend_title_text= PD['legend_title'])
    
    # Left
    T = Table.copy()
    T['Percentage'] = T['Percentage'].map(lambda x: '%%%.2f' % x)
    Temp = []
    for i in T.columns:
        Temp.append(T.loc[:,i].values)

    fig.add_trace(go.Table(header=dict(values = list(Table.columns), line_color='darkslategray',
                                       fill_color= PD['TableColors'][0], align=['center','center'],
                                       font=dict(color='white', size=12), height=25), columnwidth = PD['tablecolumnwidth'],
                           cells=dict(values=Temp, line_color='darkslategray',
                                      fill=dict(color= [PD['TableColors'][1], PD['TableColors'][1]]),
                                  align=['center', 'center'], font_size=12, height=20)), 1, 1)

    fig.update_layout(title={'text': '<b>' + Target + '<b>', 'x':PD['title_x'],
                                     'y':PD['title_y'], 'xanchor': 'center', 'yanchor': 'top'})
    fig.show()

Pull = [0 for x in range((len(Labels_dict)-1))]
Pull.append(.05)
PD = dict(PieColors = ['SeaGreen','FireBrick'],
          TableColors = ['Navy','White'], hole = .4,
          column_widths=[0.6, 0.4],textfont = 14, height = 350, tablecolumnwidth = [0.20, 0.12, 0.15],
          pull = Pull, legend_title = Target, title_x = 0.5, title_y = 0.8)
del Pull
DatasetTargetDist(Data, Target, Labels_dict, PD)

StratifiedKFold is a variation of k-fold which returns stratified folds: each set contains approximately the same percentage of samples of each target class as the complete set.

Test_Size = 0.3
sss = StratifiedShuffleSplit(n_splits=1, test_size=Test_Size, random_state=42)
_ = sss.get_n_splits(X, y)

for train_index, test_index in sss.split(X, y):
    # X
    if isinstance(X, pd.DataFrame):
        X_train, X_test = X.loc[train_index], X.loc[test_index]
    else:
        X_train, X_test = X[train_index], X[test_index]
    # y    
    if isinstance(y, pd.Series):
        y_train, y_test = y[train_index], y[test_index]
    else:
        y_train, y_test = y[train_index], y[test_index]
del sss

def Train_Test_Dist(X_train, y_train, X_test, y_test, PD, Labels_dict = Labels_dict):
    def ToSeries(x):
        if not isinstance(x, pd.Series):
            Out = pd.Series(x)
        else:
            Out = x.copy()
        return Out
    
    fig = make_subplots(rows=1, cols=3, horizontal_spacing = 0.02, column_widths= PD['column_widths'],
                        specs=[[{"type": "table"},{'type':'domain'}, {'type':'domain'}]])
    # Right
    C = 2
    for y in [ToSeries(y_train).replace(Labels_dict), ToSeries(y_test).replace(Labels_dict)]:
        fig.add_trace(go.Pie(labels= list(Labels_dict.values()),
                             values= y.value_counts().values, pull=PD['pull'],
                             textfont=dict(size=PD['textfont']),
                             marker=dict(colors = PD['PieColors'],
                             line=dict(color='black', width=1))), row=1, col=C)
        fig.update_traces(hole=.5)
        fig.update_layout(legend=dict(orientation="v"), legend_title_text= PD['legend_title'])
        C+=1
    
    # Left
    
    # Table
    Table = pd.DataFrame(data={'Set':['X_train','X_test','y_train','y_test'],
                       'Shape':[X_train.shape, X_test.shape, y_train.shape, y_test.shape]}).astype(str)
    T = Table.copy()
    Temp = []
    for i in T.columns:
        Temp.append(T.loc[:,i].values)
        
    TableColors = PD['TableColors']
    fig.add_trace(go.Table(header=dict(values = list(Table.columns), line_color='darkslategray',
                                       fill_color= TableColors[0], align=['center','center'],
                                       font=dict(color='white', size=12), height=25), columnwidth = PD['tablecolumnwidth'],
                           cells=dict(values=Temp, line_color='darkslategray',
                                      fill=dict(color= [TableColors[1], TableColors[1]]),
                                  align=['center', 'center'], font_size=12, height=20)), 1, 1)
    fig.update_layout(title={'text': '<b>' + 'Dataset Distribution' + '<b>', 'x':PD['title_x'],
                                     'y':PD['title_y'], 'xanchor': 'center', 'yanchor': 'top'})
    if not PD['height'] == None:
        fig.update_layout(height = PD['height'])
    fig.show()
    
PD.update(dict(column_widths=[0.3, 0.3, 0.3], tablecolumnwidth = [0.2, 0.4], height = 350, legend_title = Target))

Train_Test_Dist(X_train, y_train, X_test, y_test, PD)

Modeling: CatBoost Classifier

CatBoost Classifier is based on gradient boosted decision trees. During training, a set of decision trees is built consecutively. Each successive tree is built with reduced loss compared to the previous trees.

n_splits = 5
N = int(1e2)
model = catboost.CatBoostClassifier(iterations= N,
                                    task_type="GPU",
                                    devices='0:1',
                                    max_ctr_complexity=6, 
                                    random_seed= 42, od_type='Iter', od_wait=N, verbose=int(N/10), depth=5)

sss = StratifiedShuffleSplit(n_splits = n_splits, test_size=Test_Size, random_state=42)
_ = sss.get_n_splits(X, y)
Reports_Train = []
Reports_Test = []
CM_Train = []
CM_Test = []

for train_index, test_index in sss.split(X, y):
    # X
    if isinstance(X, pd.DataFrame):
        X_train, X_test = X.loc[train_index], X.loc[test_index]
    else:
        X_train, X_test = X[train_index], X[test_index]
    # y    
    if isinstance(y, pd.Series):
        y_train, y_test = y[train_index], y[test_index]
    else:
        y_train, y_test = y[train_index], y[test_index]
    #
    _ = model.fit(X_train, y_train, eval_set= (X_test, y_test), plot = False, verbose = False)
    # Train
    y_pred = model.predict(X_train)
    R = pd.DataFrame(metrics.classification_report(y_train, y_pred, target_names= list(Labels_dict.values()), output_dict=True)).T
    Reports_Train.append(R.values)
    CM_Train.append(metrics.confusion_matrix(y_train, y_pred))
    # Test
    y_pred = model.predict(X_test)
    R = pd.DataFrame(metrics.classification_report(y_test, y_pred, target_names=list(Labels_dict.values()), output_dict=True)).T
    Reports_Test.append(R.values)
    CM_Test.append(metrics.confusion_matrix(y_test, y_pred))

# Train
ALL = Reports_Train[0].ravel()
CM = CM_Train[0].ravel()
for i in range(1, len(Reports_Train)):
    ALL = np.vstack((ALL, Reports_Train[i].ravel()))
    CM = np.vstack((CM, CM_Train[i].ravel()))
Mean = pd.DataFrame(ALL.mean(axis = 0).reshape(R.shape), index = R.index, columns = R.columns)
STD = pd.DataFrame(ALL.std(axis = 0).reshape(R.shape), index = R.index, columns = R.columns)
Reports_Train = Mean.applymap(lambda x: ('%.4f' % x))+ ' ± ' +STD.applymap(lambda x: ('%.4f' % x))
CM_Train = CM.mean(axis = 0).reshape(CM_Train[0].shape).round(0).astype(int)
del ALL, Mean, STD

# Test
ALL = Reports_Test[0].ravel()
CM = CM_Test[0].ravel()
for i in range(1, len(Reports_Test)):
    ALL = np.vstack((ALL, Reports_Test[i].ravel()))
    CM = np.vstack((CM, CM_Test[i].ravel()))
Mean = pd.DataFrame(ALL.mean(axis = 0).reshape(R.shape), index = R.index, columns = R.columns)
STD = pd.DataFrame(ALL.std(axis = 0).reshape(R.shape), index = R.index, columns = R.columns)
Reports_Test = Mean.applymap(lambda x: ('%.4f' % x))+ ' ± ' +STD.applymap(lambda x: ('%.4f' % x))
CM_Test = CM.mean(axis = 0).reshape(CM_Test[0].shape).round(0).astype(int)
del ALL, Mean, STD
Reports_Train = Reports_Train.reset_index().rename(columns ={'index': 'Train Set (CV = % i)' % n_splits})
Reports_Test = Reports_Test.reset_index().rename(columns ={'index': 'Test Set (CV = % i)' % n_splits})

def Confusion_Mat(CM_Train, CM_Test, PD, n_splits = 10):
    if n_splits == None:
        Titles = ['Train Set', 'Test Set']
    else:
        Titles = ['Train Set (CV = % i)' % n_splits, 'Test Set (CV = % i)' % n_splits]
    CM = [CM_Train, CM_Test]
    Cmap = ['Greens', 'YlGn','Blues', 'PuBu']
    for i in range(2):
        fig, ax = plt.subplots(1, 2, figsize= PD['FS'])
        fig.suptitle(Titles[i], weight = 'bold', fontsize = 16)
        _ = sns.heatmap(CM[i], annot=True, annot_kws={"size": PD['annot_kws']}, cmap=Cmap[2*i], ax = ax[0],
                        linewidths = 0.2, cbar_kws={"shrink": PD['shrink']})
        _ = ax[0].set_title('Confusion Matrix');
        Temp = np.round(CM[i].astype('float') / CM[i].sum(axis=1)[:, np.newaxis], 2)
        _ = sns.heatmap(Temp,
                        annot=True, annot_kws={"size": PD['annot_kws']}, cmap=Cmap[2*i+1], ax = ax[1],
                       linewidths = 0.4, vmin=0, vmax=1, cbar_kws={"shrink": PD['shrink']})
        _ = ax[1].set_title('Normalized Confusion Matrix');

        for a in ax:
            _ = a.set_xlabel('Predicted labels')
            _ = a.set_ylabel('True labels'); 
            _ = a.xaxis.set_ticklabels(PD['Labels'])
            _ = a.yaxis.set_ticklabels(PD['Labels'])
            _ = a.set_aspect(1)

display(Reports_Train.style.hide_index().set_properties(**{'background-color': 'HoneyDew', 'color': 'Black'}).\
        set_properties(subset=['Train Set (CV = % i)' % n_splits], **{'background-color': 'SeaGreen', 'color': 'White'}))
display(Reports_Test.style.hide_index().set_properties(**{'background-color': 'Azure', 'color': 'Black'}).\
        set_properties(subset=['Test Set (CV = % i)' % n_splits], **{'background-color': 'RoyalBlue', 'color': 'White'}))

PD = dict(FS = (10, 5), annot_kws = 14, shrink = .6, Labels = list(Labels_dict.values()))
Confusion_Mat(CM_Train, CM_Test, PD = PD, n_splits = n_splits)

Train Set (CV = 5)	precision	recall	f1-score	support
Non-Diabetic	0.8683 ± 0.0078	0.9343 ± 0.0063	0.9001 ± 0.0059	350.0000 ± 0.0000
Diabetic	0.8567 ± 0.0126	0.7348 ± 0.0174	0.7910 ± 0.0135	187.0000 ± 0.0000
accuracy	0.8648 ± 0.0082	0.8648 ± 0.0082	0.8648 ± 0.0082	0.8648 ± 0.0082
macro avg	0.8625 ± 0.0091	0.8345 ± 0.0101	0.8455 ± 0.0097	537.0000 ± 0.0000
weighted avg	0.8643 ± 0.0084	0.8648 ± 0.0082	0.8621 ± 0.0085	537.0000 ± 0.0000

Test Set (CV = 5)	precision	recall	f1-score	support
Non-Diabetic	0.7839 ± 0.0111	0.8493 ± 0.0328	0.8148 ± 0.0129	150.0000 ± 0.0000
Diabetic	0.6735 ± 0.0396	0.5654 ± 0.0394	0.6127 ± 0.0177	81.0000 ± 0.0000
accuracy	0.7498 ± 0.0132	0.7498 ± 0.0132	0.7498 ± 0.0132	0.7498 ± 0.0132
macro avg	0.7287 ± 0.0189	0.7074 ± 0.0119	0.7138 ± 0.0120	231.0000 ± 0.0000
weighted avg	0.7452 ± 0.0136	0.7498 ± 0.0132	0.7440 ± 0.0114	231.0000 ± 0.0000

Test_Size = 0.3
sss = StratifiedShuffleSplit(n_splits=1, test_size=Test_Size, random_state=42)
_ = sss.get_n_splits(X, y)

for train_index, test_index in sss.split(X, y):
    # X
    if isinstance(X, pd.DataFrame):
        X_train, X_test = X.loc[train_index], X.loc[test_index]
    else:
        X_train, X_test = X[train_index], X[test_index]
    # y    
    if isinstance(y, pd.Series):
        y_train, y_test = y[train_index], y[test_index]
    else:
        y_train, y_test = y[train_index], y[test_index]
del sss

N = int(1e4)
model = catboost.CatBoostClassifier(iterations= N,
                                    task_type="GPU",
                                    devices='0:1',
                                    max_ctr_complexity=6, 
                                    random_seed= 42, od_type='Iter', od_wait=N, verbose=int(N/20), depth=5)

_ = model.fit(X_train, y_train, eval_set= (X_test, y_test), plot = False)

Learning rate set to 0.028939
0:	learn: 0.6795336	test: 0.6824103	best: 0.6824103 (0)	total: 25.7ms	remaining: 4m 16s
500:	learn: 0.2161907	test: 0.5211113	best: 0.4844795 (117)	total: 13.6s	remaining: 4m 17s
1000:	learn: 0.1389537	test: 0.5587383	best: 0.4844795 (117)	total: 35s	remaining: 5m 14s
1500:	learn: 0.1031149	test: 0.5924103	best: 0.4844795 (117)	total: 53.1s	remaining: 5m
2000:	learn: 0.0821833	test: 0.6245516	best: 0.4844795 (117)	total: 1m 4s	remaining: 4m 17s
2500:	learn: 0.0676952	test: 0.6529607	best: 0.4844795 (117)	total: 1m 15s	remaining: 3m 45s
3000:	learn: 0.0569273	test: 0.6767686	best: 0.4844795 (117)	total: 1m 26s	remaining: 3m 20s
3500:	learn: 0.0510380	test: 0.6944292	best: 0.4844795 (117)	total: 1m 36s	remaining: 2m 59s
4000:	learn: 0.0463065	test: 0.7128585	best: 0.4844795 (117)	total: 1m 47s	remaining: 2m 41s
4500:	learn: 0.0407413	test: 0.7295514	best: 0.4844795 (117)	total: 1m 58s	remaining: 2m 25s
5000:	learn: 0.0369422	test: 0.7455362	best: 0.4844795 (117)	total: 2m 9s	remaining: 2m 9s
5500:	learn: 0.0331373	test: 0.7638274	best: 0.4844795 (117)	total: 2m 20s	remaining: 1m 54s
6000:	learn: 0.0294551	test: 0.7877282	best: 0.4844795 (117)	total: 2m 31s	remaining: 1m 40s
6500:	learn: 0.0264598	test: 0.8044313	best: 0.4844795 (117)	total: 2m 42s	remaining: 1m 27s
7000:	learn: 0.0246970	test: 0.8212562	best: 0.4844795 (117)	total: 2m 53s	remaining: 1m 14s
7500:	learn: 0.0231284	test: 0.8364624	best: 0.4844795 (117)	total: 3m 5s	remaining: 1m 1s
8000:	learn: 0.0212063	test: 0.8553324	best: 0.4844795 (117)	total: 3m 16s	remaining: 49.1s
8500:	learn: 0.0188120	test: 0.8739056	best: 0.4844795 (117)	total: 3m 27s	remaining: 36.6s
9000:	learn: 0.0166493	test: 0.8916565	best: 0.4844795 (117)	total: 3m 39s	remaining: 24.3s
9500:	learn: 0.0153961	test: 0.9051500	best: 0.4844795 (117)	total: 3m 50s	remaining: 12.1s
9999:	learn: 0.0139970	test: 0.9210262	best: 0.4844795 (117)	total: 4m 1s	remaining: 0us
bestTest = 0.4844794666
bestIteration = 117
Shrink model to first 118 iterations.

# Train
y_pred = model.predict(X_train)
Reports_Train = pd.DataFrame(metrics.classification_report(y_train, y_pred, target_names=list(Labels_dict.values()), output_dict=True)).T
CM_Train = metrics.confusion_matrix(y_train, y_pred)
# Test
y_pred = model.predict(X_test)
Reports_Test = pd.DataFrame(metrics.classification_report(y_test, y_pred, target_names=list(Labels_dict.values()), output_dict=True)).T
CM_Test = metrics.confusion_matrix(y_test, y_pred)

Reports_Train = Reports_Train.reset_index().rename(columns ={'index': 'Train Set'})
Reports_Test = Reports_Test.reset_index().rename(columns ={'index': 'Test Set'})
                                                 
display(Reports_Train.style.hide_index().set_properties(**{'background-color': 'HoneyDew', 'color': 'Black'}).\
        set_properties(subset=['Train Set'], **{'background-color': 'SeaGreen', 'color': 'White'}))
display(Reports_Test.style.hide_index().set_properties(**{'background-color': 'Azure', 'color': 'Black'}).\
        set_properties(subset=['Test Set'], **{'background-color': 'RoyalBlue', 'color': 'White'}))

Confusion_Mat(CM_Train, CM_Test, PD = PD, n_splits = None)

Train Set	precision	recall	f1-score	support
Non-Diabetic	0.841709	0.957143	0.895722	350.000000
Diabetic	0.892086	0.663102	0.760736	187.000000
accuracy	0.854749	0.854749	0.854749	0.854749
macro avg	0.866897	0.810122	0.828229	537.000000
weighted avg	0.859252	0.854749	0.848716	537.000000

Test Set	precision	recall	f1-score	support
Non-Diabetic	0.775148	0.873333	0.821317	150.000000
Diabetic	0.693548	0.530864	0.601399	81.000000
accuracy	0.753247	0.753247	0.753247	0.753247
macro avg	0.734348	0.702099	0.711358	231.000000
weighted avg	0.746535	0.753247	0.744203	231.000000

The best result for each metric calculated on each validation dataset.

display(pd.DataFrame({'Train Set': {'R2 Score': model.score(X_train, y_train)},
                      'Validation Set': {'R2 Score': model.score(X_test, y_test)}}))

	Train Set	Validation Set
R2 Score	0.854749	0.753247

---

References

1. Smith, J. W., Everhart, J. E., Dickson, W. C., Knowler, W. C., & Johannes, R. S. (1988). Using the ADAP Learning Algorithm to Forecast the Onset of Diabetes Mellitus. Proceedings of the Annual Symposium on Computer Application in Medical Care, 261–265.
2. CatBoost Classifier Documentation

---